/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package shell;

import java.util.ArrayList;

/**
 *
 * @author michel
 */
public interface SystemCalls {
    
    /**
     * Método para eliminação de processos
     * @param pId = Identificador do processo
     * @param sigTerm = Sinal de tratamento, utilizar no Linux kill -l 
     * para listar todos os possíveis, utilizar 4 como referência. Utilizar
     * o -l para listar os possíveis do sistema de vocês.
     * @return Caso necessário, retorna um aviso para o usuário
     */
    public String kill(int pId, String sigTerm);
    
    /**
     * Método para eliminação de grupos de processos
     * @param gId = Elimina todos os processos de um dado grupo
     * @param sigTerm = Sinal de tratamento como no Kill, no entanto, tentem
     * tratar a eliminação de três diferentes grupos (Prontos, Executando e Bloqueados).
     * @return Caso necessário, retornar erro
     */
    public String killAll (int gId, String sigTerm);
    
    /**
     * Método para visualização de processos a partir de seu estado
     * @param sigTerm = Identifica: Pronto, Executando, Bloqueado e política
     * @return Retorna um array com todos os processos do estado solicitado ou informações
     * sobre a política que está sendo adotada no momento
     */
    public ArrayList schell(String sigTerm);
    
    /**
     * Método para manipulação das diferentes políticas do sistema operacional
     * @param sigTerm Sinal para troca de política de escalonamento
     * @param param = Quantidade dinâmica de parâmetros para inicialização da política
     * @return Caso necessário, retornar mensagem ao usuário
     */
    public String schellPolicy(int sigTerm, String... param);
    
    /**
     * Método para monitoramento da memória
     * @param sigTerm = identifica memória principal(0) ou Swap (1)
     * @return Retorna um array com a distribuição de memória até o presente
     * momento. O objetivo é criar um monitor de memória a partir do comando
     */
    public ArrayList mem (boolean sigTerm);
    
    
    /**
     * Metódo para gerencia da memória
     * @param pId = identificador do processo a ser manipulado
     * @param sigTerm = (0) envia para memória principal, (1) envia para Swap
     * @return Retorna um ArrayList com o processo a ser manipulado dentre as memórias 
     */
    public ArrayList memCopy(int pId, boolean sigTerm);
    
    
    /**
     * Método para limpeza da memória
     * @param sigTerm = (0) envia para memória principal, (1) envia para Swap
     * @return Retorna erro, caso necessário
     */
    public String memClear(boolean sigTerm);
    
    
    /**
     * Método para listagem de arquivos
     * @param sigTerm = parâmetro de listagem
     * @return Retorna um array com o resultado da execução
     */
    public ArrayList ls (String sigTerm);
    
    
    /**
     * Método para gerencia da capacidade de armazenamento
     * @param sigTerm Sinal para gerência do disco
     * @return Retorna informações sobre capacidade do disco e quanto de ocupação,
     * similar ao df do linux
     */
    public ArrayList df (String sigTerm);
    
    
    /**
     * 
     * @param sigTerm parâmetros para rastreamento do arquivo
     * @return Retorna o caminho absoluto onde se encontra o arquivo
     */
    public String find (String sigTerm);
    
    
   /**
    * Método para a criação de novos diretórios
    * @param pNome = Nome da pasta a ser criada no sistema
    * @return Caso necessário, retorna mensagem de erro
    */
    public String mkDir(String pName);
    
    
    
    /**
     * Método para a criação de novos arquivos
     * @param aName = Nome do arquivo a ser criado no sistema
     * @param path = Caminho para o salvamento, utilizar ponto ( . ) para salvar
     * no local onde se encontra o cursor
     * @return Caso necessário, retorna mensagem de erro
     */
    public String mDir (String aName, String path);
    
    
    
    /**
     * Método para a remoção de arquivos / pastas
     * @param sigTerm = diretriz de remoção, tal como o -r no linux
     * @param path = caminho absoluto para remoção do arquivo
     * @return Caso necessário, retornar erro
     */
    public String rm (String sigTerm, String path);
    
    
    /**
     * Método para inicialização de novos processos
     * @param sigTerm = Identifica qual fila o processo deve ser incorporado, na de 
     * prontos ou de bloqueados
     * @return Caso necessário, retornar erro
     */
    public String startProcess (String sigTerm);
    
    
    
    /**
     * Método para parar processos em execução
     * @param pId = Identificador do processo que será bloqueado
     * @return Caso necessário, retornar erro
     */
    public String waitProcess ( int pId);
    
    
    /**
     * 
     * @param pId Identificador do processo que está bloqueado e será enviado para
     * a fila de prontos
     * @return Caso necessário, retornar erro
     */
    public String resumeProcess (int pId);
    
}
